const express = require('express');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcryptjs');
const { v4: uuidv4 } = require('uuid');
const User = require('../models/User');
const { sendVerificationCode, verifyCode } = require('../services/emailService');
const { authenticateToken } = require('../middleware/auth');
const router = express.Router();

// JWT密钥
const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key-here';

/**
 * 用户登录接口
 * POST /auth/login
 */
router.post('/login', async (req, res) => {
  try {
    // 打印登录请求信息
    console.log('=== 收到登录请求 ===');
    const { email, password } = req.body;

    // 参数验证
    if (!email || !password) {
      return res.status(400).json({
        code: 400,
        message: '邮箱和密码不能为空',
        data: null
      });
    }

    // 邮箱格式验证
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    if (!emailRegex.test(email)) {
      return res.status(400).json({
        code: 400,
        message: '邮箱格式不正确',
        data: null
      });
    }

    // 从数据库查找用户
    const user = await User.findByEmail(email);
    if (!user) {
      return res.status(401).json({
        code: 401,
        message: '邮箱错误',
        data: null
      });
    }

    // 验证密码
    const isPasswordValid = await bcrypt.compare(password, user.password);
    // const isPasswordValid = (password === user.password)
    if (!isPasswordValid) {
      return res.status(401).json({
        code: 401,
        message: '密码错误',
        data: null
      });
    }

    // 更新用户在线状态
    await User.updateStatus(user.userId, 1);

    // 生成JWT token
    const token = jwt.sign(
      { 
        sub: user.userId,
        email: user.email
      },
      JWT_SECRET,
      { 
        expiresIn: '7d',
        algorithm: 'HS512'
      }
    );

    // 返回登录成功响应
    res.json({
      code: 200,
      message: '登录成功',
      data: {
        avatar: user.avatar,
        status: user.status,
        token: token,
        userId: user.userId,
        nickName: user.nickName
      }
    });

  } catch (error) {
    console.error('Login error:', error);
    res.status(500).json({
      code: 500,
      message: '服务器内部错误',
      data: null
    });
  }
});

/**
 * 发送注册验证码接口
 * POST /auth/send-verification-code
 */
router.post('/send-verification-code', async (req, res) => {
  try {
    const { email } = req.body;

    // 参数验证
    if (!email) {
      return res.status(400).json({
        code: 400,
        message: '邮箱不能为空',
        data: null
      });
    }

    // 邮箱格式验证
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    if (!emailRegex.test(email)) {
      return res.status(400).json({
        code: 400,
        message: '邮箱格式不正确',
        data: null
      });
    }

    // 检查邮箱是否已注册
    const existingUser = await User.findByEmail(email);
    if (existingUser) {
      return res.status(400).json({
        code: 400,
        message: '该邮箱已注册',
        data: null
      });
    }

    // 发送验证码
    const success = await sendVerificationCode(email, 'register');
    if (!success) {
      return res.status(500).json({
        code: 500,
        message: '验证码发送失败，请稍后重试',
        data: null
      });
    }

    res.json({
      code: 200,
      message: '验证码已发送到您的邮箱，请查收',
      data: null
    });

  } catch (error) {
    console.error('Send verification code error:', error);
    res.status(500).json({
      code: 500,
      message: '服务器内部错误',
      data: null
    });
  }
});

/**
 * 用户注册接口
 * POST /auth/register
 */
router.post('/register', async (req, res) => {
  try {
    const { email, password, nickName, verificationCode } = req.body;

    // 参数验证
    if (!email || !password || !verificationCode) {
      return res.status(400).json({
        code: 400,
        message: '邮箱、密码和验证码不能为空',
        data: null
      });
    }

    // 邮箱格式验证
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    if (!emailRegex.test(email)) {
      return res.status(400).json({
        code: 400,
        message: '邮箱格式不正确',
        data: null
      });
    }

    // 密码长度验证
    if (password.length < 6) {
      return res.status(400).json({
        code: 400,
        message: '密码长度不能少于6位',
        data: null
      });
    }

    // 验证验证码
    const codeVerification = verifyCode(email, verificationCode, 'register');
    if (!codeVerification.success) {
      return res.status(400).json({
        code: 400,
        message: codeVerification.message,
        data: null
      });
    }

    // 检查邮箱是否已注册
    const existingUser = await User.findByEmail(email);
    if (existingUser) {
      return res.status(400).json({
        code: 400,
        message: '该邮箱已注册',
        data: null
      });
    }

    // 加密密码
    const hashedPassword = await bcrypt.hash(password, 10);

    // 生成唯一用户ID
    const userId = uuidv4();
    
    // 创建用户数据
    const userData = {
      userId,
      email,
      password: hashedPassword, // 生产环境使用加密密码
      // password, // 开发环境暂时使用明文密码
      nickName: nickName || email.split('@')[0], // 如果没有提供昵称，使用邮箱前缀
      avatar: null,
      status: 1 // 注册后默认在线状态
    };

    // 创建用户
    const newUser = await User.create(userData);
    if (!newUser) {
      return res.status(500).json({
        code: 500,
        message: '注册失败，请稍后重试',
        data: null
      });
    }

    // 生成JWT token
    const token = jwt.sign(
      { 
        sub: newUser.userId,
        email: newUser.email
      },
      JWT_SECRET,
      { 
        expiresIn: '7d',
        algorithm: 'HS512'
      }
    );

    // 返回注册成功响应
    res.status(200).json({
      code: 200,
      message: '注册成功',
      data: {
        avatar: newUser.avatar,
        status: newUser.status,
        token: token,
        userId: newUser.userId,
        nickName: newUser.nickName
      }
    });

  } catch (error) {
    console.error('Register error:', error);
    res.status(500).json({
      code: 500,
      message: '服务器内部错误',
      data: null
    });
  }
});

/**
 * 获取当前用户信息接口
 * GET /auth/profile
 */
router.get('/profile', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.userId;

    // 从数据库获取用户信息
    const user = await User.findByUserId(userId);
    if (!user) {
      return res.status(404).json({
        code: 404,
        message: '用户不存在',
        data: null
      });
    }

    // 返回用户信息（不包含密码）
    res.json({
      code: 200,
      message: '获取用户信息成功',
      data: {
        userId: user.userId,
        email: user.email,
        nickName: user.nickName,
        avatar: user.avatar,
        status: user.status,
        createdAt: user.createdAt,
        updatedAt: user.updatedAt
      }
    });

  } catch (error) {
    console.error('获取用户信息失败:', error);
    res.status(500).json({
      code: 500,
      message: '服务器内部错误',
      data: null
    });
  }
});

/**
 * 编辑个人信息接口
 * PUT /auth/profile
 */
router.put('/profile', authenticateToken, async (req, res) => {
  try {
    const { nickName, avatar, status } = req.body;
    const userId = req.user.userId;

    // 构建更新数据对象
    const updateData = {};
    
    // 验证并添加昵称
    if (nickName !== undefined) {
      if (typeof nickName !== 'string' || nickName.trim().length === 0) {
        return res.status(400).json({
          code: 400,
          message: '昵称不能为空',
          data: null
        });
      }
      if (nickName.trim().length > 50) {
        return res.status(400).json({
          code: 400,
          message: '昵称长度不能超过50个字符',
          data: null
        });
      }
      updateData.nick_name = nickName.trim();
    }

    // 验证并添加头像
    if (avatar !== undefined) {
      if (avatar !== null && (typeof avatar !== 'string' || avatar.trim().length === 0)) {
        return res.status(400).json({
          code: 400,
          message: '头像URL格式不正确',
          data: null
        });
      }
      updateData.avatar = avatar;
    }

    // 验证并添加在线状态
    if (status !== undefined) {
      if (![0, 1, 2].includes(status)) {
        return res.status(400).json({
          code: 400,
          message: '状态值无效，只能是0(离线)、1(在线)、2(忙碌)',
          data: null
        });
      }
      updateData.status = status;
    }

    // 检查是否有要更新的字段
    if (Object.keys(updateData).length === 0) {
      return res.status(400).json({
        code: 400,
        message: '没有提供要更新的字段',
        data: null
      });
    }

    // 更新用户信息
    const updatedUser = await User.update(userId, updateData);
    
    if (!updatedUser) {
      return res.status(404).json({
        code: 404,
        message: '用户不存在',
        data: null
      });
    }

    // 返回更新后的用户信息（不包含密码）
    res.json({
      code: 200,
      message: '个人信息更新成功',
      data: {
        userId: updatedUser.userId,
        email: updatedUser.email,
        nickName: updatedUser.nickName,
        avatar: updatedUser.avatar,
        status: updatedUser.status,
        updatedAt: updatedUser.updatedAt
      }
    });

  } catch (error) {
    console.error('更新个人信息失败:', error);
    res.status(500).json({
      code: 500,
      message: '服务器内部错误',
      data: null
    });
  }
});

module.exports = router;